0

Roman KulikovGame Producer

this is the life

role

game producer, project manager & engineer

output

1,116 final illustrated frames, one cast, sixty years

building a consistent illustrated world with ai

this is the life is a narrative life-simulation game following one character from childhood to sixty. each decision is illustrated, which meant producing 1,116 images across different ages, environments, relationships and emotional situations.

generating that many images was not the difficult part. making them feel as though they belonged to the same world was.

the problem

off-the-shelf image models were good at producing individual illustrations, but bad at remembering what came before.

characters changed faces. people aged too quickly. hands broke. clothing drifted. text appeared where it should not. compositions slowly became repetitive.

the challenge became:

how do you turn an unpredictable image model into something you can actually art-direct?

rather than relying on increasingly complicated prompts, i built the pipeline around three things: style, identity and control.

the workspace before the content

the least visible phase was the largest, and it is the reason one person could keep hundreds of interdependent cards coherent at all. before a single card existed, i built the content workspace itself — nine sequential tasks, each shipped as its own commit, toward one stated goal:

hallucinated fields and flags should be impossible to ship.

the order was deliberate. the parameter registry came first, then the layered context map, then the card schema and template, then the validator — written test-first, with failing tests before a line of implementation — then the dependency graph, a pilot block, and only then something playable.

01

registry

parameters, flags, threads

02

context map

layered, loaded on demand

03

card schema

one file per situation

04

validator

written test-first

05

graph + vault

a 300-node dependency view

06

pilot block

25 cards, ages 0–5

07

prototype

built last, and disposable

the scaffolding shipped before the content. the playable prototype — the one piece a demo shows first — was built last.

the validator is the part that changed how the project felt to work in. it is not a spell-checker: it loads the registry, walks every card, and has to exit clean before anything is committed — then regenerates the card index itself, so the index cannot drift from reality.

the same instinct produced my favourite test in the repository. the prototype and the shipped app run two separate implementations of the card-selection maths, so a test extracts both, runs them over randomised game states and asserts more than 10,000 comparisons with zero mismatches — eligibility, weights, seeded draws and applied effects all identical. the two builds cannot drift into playing two different games.

teaching the model the visual language

i began by building and curating a visual reference set.

68 candidates became 65 after cleanup, then the strongest 30 were selected for training. the final dataset deliberately mixed interiors, landscapes, night scenes, winter and daylight so the model would learn the rendering language rather than memorize a narrow family of subjects.

i used it to train a custom lora on krea-2-raw.

lora is a parameter-efficient adaptation technique: rather than retraining an entire model, a relatively small set of additional weights learns the desired adaptation.[1] that made it a practical way to carry a dedicated visual language through a large production pipeline.

one trained model was not enough to trust. i later trained two more versions with adjusted dataset balance, captioning and training strength, then ran a/b comparisons on the same fixed set of test prompts — same scenes, same seeds, only the model changed.

judging them side by side made the differences obvious in a way single-model review never did, and the winning version was the one we kept for the full production run.

keeping the same people alive for sixty years

style consistency was only half the problem. the same character could still become a different person between two scenes.

i built a small character bible separating features that had to remain recognizable from those allowed to evolve.

face structure, the eye and brow region, and general proportions became stronger identity anchors. hair, clothing, posture, body composition and aging were allowed to change.

that choice was not arbitrary. research into human face recognition repeatedly finds that the eye region carries particularly important identity information, while even removing eyebrows substantially damages recognition performance.[2][3]

i then created a dedicated library of character references and used qwen reference conditioning selectively for scenes where identity really mattered.

this exposed another useful limitation: stronger conditioning did not automatically produce a better image. it could preserve a face while pulling clothes, pose or composition toward the reference.

the solution was to use references like a scalpel rather than a default setting: stronger for one visible face, weaker for groups, and often absent entirely in wide or first-person shots.

close or medium, face visible

a head-only crop of the reference portrait, attached weakly: 0.4 for a single face, 0.26 for two, 0.2 for three or more, so a family scene locks three people without any one of them taking over.

back view or first person

a back reference, or none at all — a front-facing portrait would simply turn the head around.

wide, object, empty room

description only. no reference attached.

the lock is gated by shot type: a reference drags composition with it, so it belongs only where a face actually shows.

aging without losing the character

following the same cast across decades introduced its own failure mode.

early generations aggressively interpreted age: characters in their thirties sometimes appeared grey, heavily lined and twenty years older than intended.

instead of simply adding more age words, i redesigned aging as a controlled progression. the goal was always:

the same person at another stage of life, not a newly generated older person.

perception research helped here too. facial contrast changes systematically with age and also affects how old a face is perceived to be.[4] it reinforced the idea that aging is carried by a combination of visual cues, not by turning “age” into a prompt synonym for wrinkles and grey hair.

structural identity remained stable while secondary cues were allowed to evolve gradually.

ages 0–5

ages 0–5

ages 5–10

ages 5–10

ages 10–15

ages 10–15

ages 15–20

ages 15–20

ages 25–30

ages 25–30

ages 35–40

ages 35–40

ages 40–45

ages 40–45

ages 55–60

ages 55–60

the same person, eight age blocks

art-directing the camera

once the style and cast became consistent, another problem appeared. the images were starting to look too consistent.

an audit showed that almost half of the scenes relied on essentially the same framing.

instead of introducing random camera variety, i created one rule:

the camera should change because the feeling changes.

close framing could create intimacy or discomfort. wide frames could communicate loneliness or scale. first-person worked especially well when the scene was about physical sensation, fear or vulnerability.

this also borrowed from visual-narrative research: framing determines what receives attention inside a scene, while sequential images rely on the viewer to infer what happens between visible moments.[5][6]

each card therefore became less like three separate illustrations and more like a tiny visual sequence. i recomposed 182 situations using that approach.

explicit medium, medium-wide and two-person compositions rose from roughly 1.7% to 26.9%, while cards relying entirely on the same minimal framing fell from 46.8% to 20.1%.

the numbers were diagnostics, not quotas. emotion remained the art director.

school

the years of being looked at

leaving

the paperwork of becoming someone

first work

rooms where decisions get signed

mid-life

work, home, repetition

elsewhere

a life conducted at arm’s length

later years

slower rooms, kept things

endings

night scenes and aftermath

when the model got things wrong

a large visual audit found hundreds of images that needed correction or investigation.

the failures were wonderfully predictable: malformed hands, incorrect gaze, accidental text, duplicated people, strange clothing, unwanted objects and occasional anatomical inventions nobody had requested.

hands deserved particular attention. this is not just anecdotal frustration with image generators: recent research continues to treat anatomically correct hand synthesis as a distinct generation problem because articulation, occlusion and viewpoint remain difficult for general image models.[7][8]

different defects needed different responses. small failures were corrected locally. some scenes were tested with several edit strategies and compared manually.

but the most useful rule was knowing when not to edit. if the underlying generation was structurally wrong, repairing it usually created an increasingly fragile image. those frames were rejected and regenerated.

learning to edit less

another counterintuitive discovery came during retouching. longer edit instructions often produced worse results.

a detailed request gave the editing model permission to reinterpret unrelated parts of the frame: faces changed, lighting shifted, colors moved. short, surgical instructions preserved much more of the original image.

the rule became:

change the smallest possible thing required to solve the defect.

that same principle applied to the wider pipeline. more prompting was not always more control. more reference conditioning was not always more consistency. more editing was not always a better rescue.

route, don’t rely

there was never one model that made the art. there was a changing crowd of them, and the pipeline is essentially a routing decision: send each job to the model that wins that job, and keep a written record of the ones that lost.

adopted into the pipeline

generate, primary

krea 2 large — rest api

generate, parallel

krea 2 turbo — comfyui cloud

identity lock

qwen reference conditioning

instructed edits

gpt-image

style training

hugging face trainer, krea-2-raw

evaluated, then left out

character consistency

nano banana — tried by hand, off-pipeline

instruction edit

flux.1 kontext — scaffolded, never run

identity

ip-adapter / instantid — wrong model family

edits without spend

local qwen edit graph — built, unused

solid: in the committed pipeline. dashed: tried, measured and deliberately not shipped.

both render routes run from the same manifest and the same seed, derived from the image id, so any frame is reproducible and the two routes stay comparable frame for frame. that also made the money predictable in advance: roughly six cents a frame, about seventy dollars for the deck, with a rework buffer on top and a standing rule that no paid batch runs without an explicit go-ahead.

around all of it turns one loop. it is genuinely cyclic — steps five through seven send work back to step one often enough that the log matters more than memory.

01

draft

cards and prompts

02

validate

the gate has to pass

03

balance

a human edit sheet

04

render

two routes, one seed

05

audit

defects, gaze, legible text

06

edit

targeted repair or re-render

07

decide

a human picks the winner

08

publish

into the deck

re-open. every ruling is appended to a decision log, so six months later the file tree can still explain itself.

ai proposes; deterministic checks and a human dispose.

that sentence is the whole method. agents drafted, rewrote and reviewed at scale; a linter and one person decided. when an ai reviewer proved unreliable — over-flagging intended redesigns, occasionally inventing problems — it was demoted to advisory rather than trusted harder.

what did not work

some of the most useful decisions came from abandoning approaches that looked reasonable on paper.

describing an already-trained style

the extra style language fought the lora. it was removed.

attaching character references everywhere

identity improved, but composition deteriorated. conditioning became shot-dependent.

letting the model interpret age freely

characters aged too aggressively. aging became a controlled visual system.

using ai as the final visual reviewer

the reviewer sometimes flagged intentional changes and occasionally invented problems. it was demoted to advisory.

trying to rescue every generation

some frames were simply too broken. regeneration was cheaper and cleaner than increasingly destructive editing.

what the project changed

the project began as an experiment in generating a large illustrated game. it became an exercise in controlling generative systems.

the biggest lessons were surprisingly simple:

01

train repeatable style instead of describing it endlessly.

02

treat character identity as its own problem.

03

use references only where they genuinely help.

04

let different models do the jobs they are actually good at.

05

make composition serve the emotional idea.

06

fix local failures locally, but regenerate broken foundations.

and most importantly:

never confuse generation with art direction.

ai made producing 1,116 frames possible — and around a thousand more test frames behind them, spent on calibration and the search for the style. the real work was deciding what each frame should communicate, recognizing when the model missed it, understanding why, and building a reliable way to bring the result back under control.

selected research

  1. 1hu, e. j. et al. lora: low-rank adaptation of large language models. iclr, 2022. arxiv:2106.09685.
  2. 2sadr, j., jarudi, i. & sinha, p. the role of eyebrows in face recognition. perception 32(3), 2003. doi:10.1068/p5027.
  3. 3royer, j. et al. greater reliance on the eye region predicts better face recognition ability. cognition 181, 2018. doi:10.1016/j.cognition.2018.08.004.
  4. 4porcheron, a., mauger, e. & russell, r. aspects of facial contrast decrease with age and are cues for age perception. plos one 8(3), 2013. doi:10.1371/journal.pone.0057985.
  5. 5cohn, n., taylor-weiner, a. & grossman, s. framing attention in japanese and american comics: cross-cultural differences in attentional structure. frontiers in psychology 3, 2012. doi:10.3389/fpsyg.2012.00349.
  6. 6iyyer, m. et al. the amazing mysteries of the gutter: drawing inferences between panels in comic book narratives. arxiv:1611.05118, 2016.
  7. 7zhang, h. et al. hand1000: generating realistic hands from text with only 1,000 images. arxiv:2408.15461, 2024.
  8. 8chen, k. et al. foundhand: large-scale domain-specific learning for controllable hand image generation. arxiv:2412.02690, 2024.